{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: This example is compatible with versions v0.2.1dev or higher (i.e., up to date with GitHub). For instructions on how to run with latest pip stable versions (<=v0.1.5), see [this](https://github.com/facebookresearch/mbrl-lib/blob/main/notebooks/pets_example_v0.1.5.ipynb) notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preview\n",
    "\n",
    "In this example, we are going to use our toolbox to write the [PETS](https://arxiv.org/pdf/1805.12114.pdf) algorithm (Chua at al., 2018), and use it to solve a continuous version of the cartpole environment. PETS is a model-based algorithm that consists of two main components: an ensemble of probabilistic models (each a feed-forward neural network), and a planner using the [Cross-Entropy Method](https://people.smp.uq.edu.au/DirkKroese/ps/aortut.pdf) (de Boer et al., 2004). \n",
    "\n",
    "A basic implementation of this algorithm consists of the following sequence of steps:\n",
    "\n",
    "1. Gather data using an exploration policy\n",
    "2. Repeat:<br>\n",
    "  2.1. Train the dynamics model using all available data.<br>\n",
    "  2.2. Do a trajectory on the environment, choosing actions with the planner, using the dynamics model to simulate environment transitions.\n",
    "  \n",
    "The ensemble model is trained to predict the environment's dynamics, and the planner tries to find high-reward trajectories over the model dynamics. \n",
    "\n",
    "To implement this using `MBRL-Lib`, we will use an ensemble of neural networks (NNs) modelling Gaussian distributions (available in the [mbrl.models](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.GaussianMLP) module), and a trajectory optimizer agent that uses CEM (available in the [mbrl.planning](https://luisenp.github.io/mbrl-lib/planning.html#mbrl.planning.TrajectoryOptimizerAgent) module). We will also rely on several of the utilities available in the [mbrl.util](https://luisenp.github.io/mbrl-lib/util.html) module. Finally, we will wrap the dynamics model into a [gym-like environment](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.ModelEnv) over which we can plan action sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import omegaconf\n",
    "\n",
    "import mbrl.env.cartpole_continuous as cartpole_env\n",
    "import mbrl.env.reward_fns as reward_fns\n",
    "import mbrl.env.termination_fns as termination_fns\n",
    "import mbrl.models as models\n",
    "import mbrl.planning as planning\n",
    "import mbrl.util.common as common_util\n",
    "import mbrl.util as util\n",
    "\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "mpl.rcParams.update({\"font.size\": 16})\n",
    "\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the environment\n",
    "\n",
    "First we instantiate the environment and specify which reward function and termination function to use with the gym-like environment wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 0\n",
    "env = cartpole_env.CartPoleEnv()\n",
    "env.seed(seed)\n",
    "rng = np.random.default_rng(seed=0)\n",
    "generator = torch.Generator(device=device)\n",
    "generator.manual_seed(seed)\n",
    "obs_shape = env.observation_space.shape\n",
    "act_shape = env.action_space.shape\n",
    "\n",
    "# This functions allows the model to evaluate the true rewards given an observation \n",
    "reward_fn = reward_fns.cartpole\n",
    "# This function allows the model to know if an observation should make the episode end\n",
    "term_fn = termination_fns.cartpole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hydra configuration\n",
    "\n",
    "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "trial_length = 200\n",
    "num_trials = 10\n",
    "ensemble_size = 5\n",
    "\n",
    "# Everything with \"???\" indicates an option with a missing value.\n",
    "# Our utility functions will fill in these details using the \n",
    "# environment information\n",
    "cfg_dict = {\n",
    "    # dynamics model configuration\n",
    "    \"dynamics_model\": {\n",
    "        \"_target_\": \"mbrl.models.GaussianMLP\",\n",
    "        \"device\": device,\n",
    "        \"num_layers\": 3,\n",
    "        \"ensemble_size\": ensemble_size,\n",
    "        \"hid_size\": 200,\n",
    "        \"in_size\": \"???\",\n",
    "        \"out_size\": \"???\",\n",
    "        \"deterministic\": False,\n",
    "        \"propagation_method\": \"fixed_model\",\n",
    "        # can also configure activation function for GaussianMLP\n",
    "        \"activation_fn_cfg\": {\n",
    "            \"_target_\": \"torch.nn.LeakyReLU\",\n",
    "            \"negative_slope\": 0.01\n",
    "        }\n",
    "    },\n",
    "    # options for training the dynamics model\n",
    "    \"algorithm\": {\n",
    "        \"learned_rewards\": False,\n",
    "        \"target_is_delta\": True,\n",
    "        \"normalize\": True,\n",
    "    },\n",
    "    # these are experiment specific options\n",
    "    \"overrides\": {\n",
    "        \"trial_length\": trial_length,\n",
    "        \"num_steps\": num_trials * trial_length,\n",
    "        \"model_batch_size\": 32,\n",
    "        \"validation_ratio\": 0.05\n",
    "    }\n",
    "}\n",
    "cfg = omegaconf.OmegaConf.create(cfg_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>Note: </b> This example uses a probabilistic ensemble. You can also use a fully deterministic model with class GaussianMLP by setting ensemble_size=1, and deterministic=True. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a dynamics model\n",
    "\n",
    "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 1-D dynamics model for this environment\n",
    "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n",
    "\n",
    "# Create a gym-like environment to encapsulate the model\n",
    "model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a replay buffer\n",
    "\n",
    "We can create a replay buffer for this environment an configuration using the following method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_buffer = common_util.create_replay_buffer(cfg, obs_shape, act_shape, rng=rng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now populate the replay buffer with random trajectories of a desired length, using a single function call to `util.rollout_agent_trajectories`. Note that we pass an agent of type `planning.RandomAgent` to generate the actions; however, this method accepts any agent that is a subclass of `planning.Agent`, allowing changing exploration strategies with minimal changes to the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# samples stored 200\n"
     ]
    }
   ],
   "source": [
    "common_util.rollout_agent_trajectories(\n",
    "    env,\n",
    "    trial_length, # initial exploration steps\n",
    "    planning.RandomAgent(env),\n",
    "    {}, # keyword arguments to pass to agent.act()\n",
    "    replay_buffer=replay_buffer,\n",
    "    trial_length=trial_length\n",
    ")\n",
    "\n",
    "print(\"# samples stored\", replay_buffer.num_stored)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CEM Agent\n",
    "\n",
    "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_cfg = omegaconf.OmegaConf.create({\n",
    "    # this class evaluates many trajectories and picks the best one\n",
    "    \"_target_\": \"mbrl.planning.TrajectoryOptimizerAgent\",\n",
    "    \"planning_horizon\": 15,\n",
    "    \"replan_freq\": 1,\n",
    "    \"verbose\": False,\n",
    "    \"action_lb\": \"???\",\n",
    "    \"action_ub\": \"???\",\n",
    "    # this is the optimizer to generate and choose a trajectory\n",
    "    \"optimizer_cfg\": {\n",
    "        \"_target_\": \"mbrl.planning.CEMOptimizer\",\n",
    "        \"num_iterations\": 5,\n",
    "        \"elite_ratio\": 0.1,\n",
    "        \"population_size\": 500,\n",
    "        \"alpha\": 0.1,\n",
    "        \"device\": device,\n",
    "        \"lower_bound\": \"???\",\n",
    "        \"upper_bound\": \"???\",\n",
    "        \"return_mean_elites\": True,\n",
    "        \"clipped_normal\": False\n",
    "    }\n",
    "})\n",
    "\n",
    "agent = planning.create_trajectory_optim_agent_for_model(\n",
    "    model_env,\n",
    "    agent_cfg,\n",
    "    num_particles=20\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running PETS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having a model and an agent, we can now run PETS with a simple loop and a few function calls. The first code block creates a callback to pass to the model trainer to accumulate the training losses and validation scores observed. The second block is just a utility function to update the agent's visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses = []\n",
    "val_scores = []\n",
    "\n",
    "def train_callback(_model, _total_calls, _epoch, tr_loss, val_score, _best_val):\n",
    "    train_losses.append(tr_loss)\n",
    "    val_scores.append(val_score.mean().item())   # this returns val score per ensemble model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_axes(_axs, _frame, _text, _trial, _steps_trial, _all_rewards, force_update=False):\n",
    "    if not force_update and (_steps_trial % 10 != 0):\n",
    "        return\n",
    "    _axs[0].imshow(_frame)\n",
    "    _axs[0].set_xticks([])\n",
    "    _axs[0].set_yticks([])\n",
    "    _axs[1].clear()\n",
    "    _axs[1].set_xlim([0, num_trials + .1])\n",
    "    _axs[1].set_ylim([0, 200])\n",
    "    _axs[1].set_xlabel(\"Trial\")\n",
    "    _axs[1].set_ylabel(\"Trial reward\")\n",
    "    _axs[1].plot(_all_rewards, 'bs-')\n",
    "    _text.set_text(f\"Trial {_trial + 1}: {_steps_trial} steps\")\n",
    "    display.display(plt.gcf())  \n",
    "    display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following lines implement the PETS algorithm. First, we create a model trainer and pass some hyperparameters for the optimizer (Adam), along with references to the model instance to use. Then we start a loop where we execute actions of ``agent`` in the environment and train the model at the beginning of the episode (by calling ``model_trainer.train()``. At every step in the loop, we execute an agent action in the environment and populate the replay buffer by calling ``util.step_env_and_add_to_buffer()``. Importantly, at the beginning of each episode we also call ``agent.reset()`` to clear any episode dependent cache; in the case of a ``TrajectoryOptimizerAgent``, this means clearing the previous action sequence found, which is shifted at every call to obtain an initial solution for the optimizer. \n",
    "\n",
    "The rest of the code is mostly bookkeeping to keep track of the total reward observed during each episode, and to make sure episodes terminate after some desired length. After running this code, you should see the agent reaching the maximum reward of 200 after a few episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x270 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a trainer for the model\n",
    "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-3, weight_decay=5e-5)\n",
    "\n",
    "# Create visualization objects\n",
    "fig, axs = plt.subplots(1, 2, figsize=(14, 3.75), gridspec_kw={\"width_ratios\": [1, 1]})\n",
    "ax_text = axs[0].text(300, 50, \"\")\n",
    "    \n",
    "# Main PETS loop\n",
    "all_rewards = [0]\n",
    "for trial in range(num_trials):\n",
    "    obs = env.reset()    \n",
    "    agent.reset()\n",
    "    \n",
    "    done = False\n",
    "    total_reward = 0.0\n",
    "    steps_trial = 0\n",
    "    update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n",
    "    while not done:\n",
    "        # --------------- Model Training -----------------\n",
    "        if steps_trial == 0:\n",
    "            dynamics_model.update_normalizer(replay_buffer.get_all())  # update normalizer stats\n",
    "            \n",
    "            dataset_train, dataset_val = common_util.get_basic_buffer_iterators(\n",
    "                replay_buffer,\n",
    "                batch_size=cfg.overrides.model_batch_size,\n",
    "                val_ratio=cfg.overrides.validation_ratio,\n",
    "                ensemble_size=ensemble_size,\n",
    "                shuffle_each_epoch=True,\n",
    "                bootstrap_permutes=False,  # build bootstrap dataset using sampling with replacement\n",
    "            )\n",
    "                \n",
    "            model_trainer.train(\n",
    "                dataset_train, \n",
    "                dataset_val=dataset_val, \n",
    "                num_epochs=50, \n",
    "                patience=50, \n",
    "                callback=train_callback,\n",
    "                silent=True)\n",
    "\n",
    "        # --- Doing env step using the agent and adding to model dataset ---\n",
    "        next_obs, reward, done, _ = common_util.step_env_and_add_to_buffer(\n",
    "            env, obs, agent, {}, replay_buffer)\n",
    "            \n",
    "        update_axes(\n",
    "            axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n",
    "        \n",
    "        obs = next_obs\n",
    "        total_reward += reward\n",
    "        steps_trial += 1\n",
    "        \n",
    "        if steps_trial == trial_length:\n",
    "            break\n",
    "    \n",
    "    all_rewards.append(total_reward)\n",
    "\n",
    "update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards, force_update=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, below we check the results of the trainer callback, which show the training loss and validation score across all calls to ``model_trainer.train()``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 1, figsize=(12, 10))\n",
    "ax[0].plot(train_losses)\n",
    "ax[0].set_xlabel(\"Total training epochs\")\n",
    "ax[0].set_ylabel(\"Training loss (avg. NLL)\")\n",
    "ax[1].plot(val_scores)\n",
    "ax[1].set_xlabel(\"Total training epochs\")\n",
    "ax[1].set_ylabel(\"Validation score (avg. MSE)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Where to learn more about MBRL?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn about the other features of the library, please check out our [documentation](https://facebookresearch.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/pets.py), [MBPO](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/mbpo.py), and [PlaNet](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/planet.py), and their configuration [files](https://github.com/facebookresearch/mbrl-lib/tree/main/mbrl/examples/conf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mbrl",
   "language": "python",
   "name": "mbrl"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
